home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1998 November: Tool Chest / Dev.CD Nov 98 TC.toast / Sample Code / Snippets / Toolbox / DialogBits / Source / DialogBits 2.0.1.c
Encoding:
C/C++ Source or Header  |  1996-09-23  |  32.5 KB  |  798 lines  |  [TEXT/CWIE]
  1. /* DialogBits
  2. * providing a bunch of dialog manager snippets */
  3. /*************************************************************
  4. This sample shows how to deal with many of the most commonly asked Dialog Manager
  5. questions.  Dimming edit lines, using userItems, restricting edit lines to
  6. specific lengths, and some other stuff is included here.
  7. The programming style used here is designed to clearly show the specific
  8. actions I'm taking, _not_ to show good coding practice.  Obviously, you will 
  9. want to modify and optimize this code for your specific application.
  10. C.K. Haun
  11. Apple Developer Tech Support
  12. *************************************************************/
  13. /*
  14. v 2.0.1 July '92
  15. Change for version 2.0.1
  16. Added a variable item, varies between static text and edit text.
  17.     Lots of folks have asked how to do this, and this shows the safest
  18.     way to do so.
  19.     Is this a good interface (switching between static and edit text)?
  20.     I dunno, I've had many people say "NO! Never do that!" and others say 
  21.     "Yeah, if it makes sense.".  I'm not making any value judgements, it's
  22.     your applications, if it makes sense to you have fun.
  23. */
  24.  
  25. /*
  26.  
  27. v 2.0 April '92
  28. Changes for version 2.0
  29. If available, use the new Dialog Manager routines.
  30. Added a control item
  31. Added code to check for DialogDispatch trap
  32. Added code to show how to check for 'Paste' in a size-limited edit field
  33.  
  34. */
  35.  
  36. //updates 8/96: Prefix.h added as prefix file for 68K and PPC projects; old
  37. //routine names changed
  38.  
  39. // 9/96 fixed gDimEditLineUPP creation -afd
  40.  
  41. #include <Dialogs.h>
  42. #include <Controls.h>
  43. #include <QuickDraw.h>
  44. #include <Windows.h>
  45. #include <ToolUtils.h>
  46. #include <OSUtils.h>
  47. #include <Menus.h>
  48. #include <Fonts.h>
  49. #include <resources.h>
  50. #include <Sound.h>
  51. #include <Traps.h>
  52. #include <Gestaltequ.h>
  53. #include <Memory.h>
  54. #include <Scrap.h>
  55. #include <TextEdit.h>
  56. #include <Icons.h>
  57. /* item numbers */
  58.  
  59. /* this stuff would normally be in your .h file, but in this simple example */
  60. /* I just put them here */
  61. /* I like enums, hate #defines */
  62. enum  {
  63.     /* ok and cancel are already defined in Dialogs.h */
  64.     kTitleItem = 3, 
  65.     kFredIconItem, 
  66.     kBottomEditLine, 
  67.     kSpinItem, 
  68.     kTopEditLine, 
  69.     kEditCheckBox, 
  70.     kDimmingBox,
  71.     kSayClickFred, 
  72.     kSayWhichVersItem, 
  73.     kScrollControlItem, 
  74.     kSayRotationSpeedItem, 
  75.     kSlowWordItem, 
  76.     kFastWordItem, 
  77.     /* 2.0.1 */
  78.     kStatTextVaryItem,
  79.     kEditTextVaryItem,
  80.     kVaryTextCheckBoxItem,
  81.     kBorderBox
  82. };
  83. enum  {
  84.     kSampleDialog = 128, 
  85.     kBaseSpinIcon = 129
  86. };
  87. enum  {
  88.     kSoundID = 128, 
  89.     kFredIconID = 128, 
  90.     kSysEnvironsVersion = 1, 
  91.     kNotWord = 128
  92. };
  93. /* key equates */
  94. enum  {
  95.     kEnterKey = 0x03, 
  96.     kTabKey = 9, 
  97.     kReturnKey = 0x0D, 
  98.     kBackSpace = 8, 
  99.     kEscKey = 0x1B, 
  100.     kLeftArrow = 0x1C, 
  101.     kRightArrow, 
  102.     kUpArrow,
  103.     kDownArrow, 
  104.     kDeleteKey = 0x7F
  105. };
  106.  
  107. /* prototypes */
  108. ControlHandle SnatchHandle(DialogPtr thebox, short theGetItem);
  109. void SpinIt(DialogPtr theDialog);
  110. pascal Boolean filterIt(DialogPtr inputDialog, EventRecord *myDialogEvent, short *theDialogItem);
  111. Boolean IsEditKey(char theKey, short modifiers);
  112. void IBeamIt(WindowPtr dwind);
  113. pascal     void BorderDefault(WindowPtr dwind, short dinum);
  114. pascal     void DimEditLine(WindowPtr dwind, short dinum);
  115. pascal     void DoScrollArrows(ControlHandle theControl, short thePart);
  116. Boolean TrapAvailable(short tNumber);
  117. short HasSelectionRange(DialogPeek inputDialog);
  118. pascal     void NOPRoutine(WindowPtr dwind, short dinum);
  119.  
  120. /* not strictly necessary, this is set by a call to  */
  121. /* TrapAvailable to see if the new dialog dispatch routines are in. */
  122. /* So, you could call TrapAvail all the time instead of using this global */
  123. Boolean gNewDialog = true;
  124.  
  125. ControlActionUPP gControlActionUPP; /* added to support the Universal Interfaces */
  126. ModalFilterUPP   gModalFilterUPP;
  127.  
  128. UserItemUPP      gNOPRoutineUPP;    /* UPPs for our user item routines */
  129. UserItemUPP      gBorderDefaultUPP;
  130. UserItemUPP      gDimEditLineUPP;
  131.  
  132. void main(void)
  133. {
  134.     DialogPtr myDialog = nil;                               /* the dialog wee're using */
  135.     short hitItem = 0;                                      /* hitItem for ModalDialog */
  136.     Rect tempRect;                                          /* these  three are here for all the GetDialogItem/SetDialogItem calls*/
  137.     short tempItem;
  138.     Handle tempHandle;
  139.     Boolean tempBool;                                       /* a temporary boolean (now THAT'S a helpful comment */
  140.     Handle theSound;
  141.     Str255 tempString, tempString2;
  142.     /* start up managers */
  143.     InitGraf(&qd.thePort);
  144.     InitFonts();
  145.     InitWindows();
  146.     InitMenus();
  147.     TEInit();
  148.     InitDialogs(nil);
  149.     InitCursor();
  150.     
  151.     /* set up our control action UPP */
  152.     gControlActionUPP = NewControlActionProc(DoScrollArrows);
  153.     
  154.     /* set up our modal filter UPP */
  155.     gModalFilterUPP = NewModalFilterProc(filterIt);
  156.     
  157.     /* create the UPPs for out user items here */
  158.     gNOPRoutineUPP = NewUserItemProc(NOPRoutine);
  159.     gBorderDefaultUPP = NewUserItemProc(BorderDefault);
  160.     gDimEditLineUPP   = NewUserItemProc(DimEditLine);
  161.     
  162.    /* get our dialog.  It is created HIDDEN, and shown after I set all */
  163.     /* the user items to their functions */
  164.     myDialog = GetNewDialog(kSampleDialog, nil, (WindowPtr)-1);
  165.     
  166.     /* See if the DialogDispatch trap is available for using the new calls */
  167.     gNewDialog = TrapAvailable(_DialogDispatch);
  168.    
  169.    gNewDialog = true;
  170.     
  171.     /* add a NOT word to my string if they aren't */
  172.     if (gNewDialog == false) {
  173.         Handle theWord = GetResource('STR ', kNotWord);
  174.         if (theWord) {
  175.             HLock(theWord);
  176.             GetDialogItemText(theWord, tempString2);
  177.             ParamText((ConstStr255Param)tempString2, (ConstStr255Param)"", (ConstStr255Param)"", (ConstStr255Param)"");
  178.             HUnlock(theWord);
  179.             ReleaseResource(theWord);
  180.         }
  181.     }
  182.     /* set up our user items for various things */
  183.     
  184.     /* Switch here for Sys 7 or prior */
  185.     /* We'll set up our default and cancel items for gNewDialog, and also shorten */
  186.     /* the DITL to remove the user item I had in there to border the OK button */
  187.     /* Testing for System 7 is appropriate for the new DM calls, but for the */
  188.     /* Append/Delete DITL calls there is a specific selector, so we'll use that also */
  189.     if (gNewDialog) {
  190.         long gestaltReturn;
  191.         OSErr myErr;
  192.         SetDialogDefaultItem(myDialog, ok);
  193.         SetDialogCancelItem(myDialog, cancel);
  194.         SetDialogTracksCursor(myDialog, true);
  195.         
  196.         /* If we have the new calls, we can (and should) take the bounding */
  197.         /* box user item off our item list */
  198.         /* see if ShortenDILT exisits */
  199.         myErr = Gestalt(gestaltDITLExtAttr, &gestaltReturn);
  200.         if ((myErr == noErr) && (gestaltReturn & 0x1)) {
  201.             ShortenDITL(myDialog, 1);
  202.         } else {
  203.             
  204.             /* something weird happened, we have the new Dialog calls but not  */
  205.             /* shortenDITL.  So make the bounding box item a NOP, but we still */
  206.             /* MUST have it point to something */
  207.             GetDialogItem(myDialog, kBorderBox, &tempItem, &tempHandle, &tempRect);
  208.             SetDialogItem(myDialog, kBorderBox, tempItem, (Handle)gNOPRoutineUPP, &tempRect);
  209.             
  210.         }
  211.     } else {
  212.         /* no new calls, set up the bordering box ourselves */
  213.         GetDialogItem(myDialog, kBorderBox, &tempItem, &tempHandle, &tempRect);
  214.         SetDialogItem(myDialog, kBorderBox, tempItem, (Handle) gBorderDefaultUPP, &tempRect);
  215.     }
  216.     
  217.     /* set up the user item that will dim the edit line when it is disabled */
  218.     GetDialogItem(myDialog, kDimmingBox, &tempItem, &tempHandle, &tempRect);
  219.     SetDialogItem(myDialog, kDimmingBox, tempItem, (Handle)gDimEditLineUPP, &tempRect);
  220.     
  221.     /* make sure the enabled checkbox for the edit line is FALSE */
  222.     tempHandle = (Handle)SnatchHandle(myDialog, kEditCheckBox);
  223.     SetControlValue((ControlHandle)tempHandle, false);
  224.     
  225.     /* and since I want this edit line dimmed when the box first shows up, I'll */
  226.     /* select the other edit line */
  227.     SelectDialogItemText((DialogPtr)myDialog, kTopEditLine, 0, 0);
  228.     /* 2.0.1 adding switchable text*/
  229.     HideDialogItem(myDialog,kEditTextVaryItem);
  230.     
  231.     
  232.     /* show it */
  233.     ShowWindow((WindowPtr)myDialog);
  234.     
  235.     /* draw it once */
  236.     DrawDialog(myDialog);
  237.     
  238.     do {
  239.         ModalDialog(gModalFilterUPP, &hitItem);
  240.         switch (hitItem) {
  241.             case kFredIconItem:
  242.                 /* if they click on Fred, have him express his opinion */
  243.                 theSound = GetResource('snd ', kSoundID);
  244.                 if (theSound != nil) {
  245.                     SndPlay(nil, (SndListHandle)theSound, false);
  246.                     ReleaseResource(theSound);
  247.                 }
  248.                 break;
  249.             case kEditCheckBox:
  250.                 /* edit line dim checkbox */
  251.                 
  252.                 tempHandle = (Handle)SnatchHandle(myDialog, kEditCheckBox);
  253.                 tempBool = GetControlValue((ControlHandle)tempHandle);
  254.                 if (tempBool == true) tempBool = false;
  255.                   else tempBool = true;
  256.                 SetControlValue((ControlHandle)tempHandle, tempBool);
  257.                 if (tempBool == false) {
  258.                     /* they turned the edit line off, we need to switch out of the EL if its */
  259.                     /* active */
  260.                     if (((DialogPeek)myDialog)->editField + 1 == kBottomEditLine)
  261.                         SelectDialogItemText((DialogPtr)myDialog, kTopEditLine, 0, 0);
  262.                 }
  263.                 /* whatever they did, invalidate the rect so the edit line is dimmed/not  */
  264.                 /* dimmed correctly */
  265.                 GetDialogItem(myDialog, kDimmingBox, &tempItem, &tempHandle, &tempRect);
  266.                 /* way paranoid, but once you've invalidated a rect in the wrong port */
  267.                 /* you never want to do it again */
  268.                 SetPort(myDialog);
  269.                 InvalRect(&tempRect);
  270.                 break;
  271.             case kVaryTextCheckBoxItem:
  272.             tempHandle = (Handle)SnatchHandle(myDialog, kVaryTextCheckBoxItem);
  273.                 tempBool = GetControlValue((ControlHandle)tempHandle);
  274.                 tempBool = tempBool ? false : true;
  275.                 SetControlValue((ControlHandle)tempHandle,tempBool);
  276.                 if(tempBool){
  277.                 HideDialogItem(myDialog,kStatTextVaryItem);
  278.                 ShowDialogItem(myDialog,kEditTextVaryItem);
  279.                 } else {
  280.                 /* when we switch from edit text to static text, we want the */            
  281.                 /* static text to say the same thing as the edit text, so let's do that */
  282.                 GetDialogItemText((Handle)SnatchHandle(myDialog, kEditTextVaryItem), tempString);
  283.                 SetDialogItemText((Handle)SnatchHandle(myDialog, kStatTextVaryItem),tempString);
  284.                 HideDialogItem(myDialog,kEditTextVaryItem);
  285.                 ShowDialogItem(myDialog,kStatTextVaryItem);
  286.                 
  287.                 }
  288.             /* whatever we did with this, we have to change the selection */    
  289.             if(tempBool){
  290.             /* if they just turned us on, move the selection to us */
  291.             SelectDialogItemText((DialogPtr)myDialog, kEditTextVaryItem, 0, 0);
  292.         
  293.             } else {
  294.             /* else move to the top line */
  295.                SelectDialogItemText((DialogPtr)myDialog, kTopEditLine, 0, 0);
  296.             
  297.             }
  298.             break;
  299.                 
  300.         }
  301.     }
  302.             while (hitItem != ok && hitItem != cancel);
  303.     DisposeDialog(myDialog);
  304.     InitCursor();                                           /* Init to prevent I-beam from hanging around in some circumstances */
  305. } /* end main */
  306.  
  307. /* My dialog filter.  It's pretty crowded here, since I'm showing lots of */
  308. /* stuff.  You'd of course want it neatened up a bit */
  309. pascal     Boolean filterIt(DialogPtr inputDialog, EventRecord *myDialogEvent, short *theDialogItem)
  310. {
  311.     WindowPtr tempWindowPtr;
  312.     ModalFilterUPP theModalProc;
  313.     char theKey;
  314.     Rect tempRect;
  315.     short tempItem;
  316.     Handle tempHandle;
  317.     long tilticks;
  318.     Boolean returnVal = false;
  319.     char tempKey;
  320.     Str255 myStr;
  321.     long offset;
  322.     short selection;
  323.     long scrapLen;
  324.     short resultLen;
  325.     Point mousePoint;
  326.     Boolean hiLit = false;
  327.     Point tempPoint;
  328.     short thePart;
  329.     ControlHandle returnedControl;
  330.     OSErr myErr;
  331.     Boolean wasAKey = false;    
  332.     /* save the current port, and set the port to us */
  333.     GetPort(&tempWindowPtr);
  334.     SetPort(inputDialog);
  335.     
  336.     /**********************************************************************/
  337.     /* Use something like this if you want to do any idle time drawing in your */
  338.     /* dialog, like a clock, flashing cursor, or a classy animated icon like I'm using */
  339.     /**********************************************************************/
  340.     SpinIt(inputDialog);
  341.     
  342.     /**********************************************************************
  343.     IBeamIt changes the cursor to an IBeam cursor when the cursor is over
  344.     the active edit line.
  345.     Of course, if we're in System 7, we have already made the DialogTracksCursor
  346.     call, so we don't need this.
  347.     **********************************************************************/
  348.     if (gNewDialog == false)
  349.         IBeamIt(inputDialog);
  350.     
  351.     /*************************************************************/
  352.     /* Some key filtering schemes follow.  The first is the standard filter to */
  353.     /* recognize 'return' as OK and 'ESC' as cancel.  What this really means */
  354.     /* is that I never ever want to have to use the mouse to click the cancel */
  355.     /* buttton ever again, you can just cut and paste this code from now on. */
  356.     /***********************************************************************/
  357.     /* do standard filtering for escape and return as OK and Cancel aliases */
  358.     /* We also invert the button in the dialog, so the user get's visual feedback */
  359.     /* about the action they just took */
  360.     /* Again, if we're using the new calls, then we don't need to do this particular */
  361.     /* filtering */
  362.     wasAKey = (myDialogEvent->what == keyDown) || (myDialogEvent->what == autoKey);
  363.         /* this 'if' has a double key check because of the 'tab' key restriction */
  364.         /* I'm doing.  If the new dialog manager calls are being used, we do NOT */
  365.         /* want to pass the tab key through to the standard filter, since it will */
  366.         /* tab to the other edit line even if we have it turned off */
  367.     if ((gNewDialog == false || (wasAKey && ((myDialogEvent->message & charCodeMask) == kTabKey)) ) && wasAKey) {
  368.         theKey = myDialogEvent->message & charCodeMask;
  369.         switch (theKey) {
  370.             case kReturnKey:
  371.             case kEnterKey:                                 /* enter key */
  372.                 /* This filters for Return or Enter as item 1, and Esc as item 2 */
  373.                 *theDialogItem = ok;                        /* change whatever the current item is to the OK item */
  374.                 /* now we need to invert the button */
  375.                 HiliteControl(SnatchHandle(inputDialog, ok), 10);
  376.                 Delay(8, &tilticks);                        /* wait about 8 ticks so they can see it */
  377.                 HiliteControl(SnatchHandle(inputDialog, ok), false);
  378.                 SetPort(tempWindowPtr);
  379.                 returnVal = true;
  380.                 break;
  381.                 /* This filters the escape key as the same as item 2 (the canx button, usually ) */
  382.             case kEscKey:
  383.                 *theDialogItem = cancel;
  384.                 HiliteControl(SnatchHandle(inputDialog, cancel), 10);
  385.                 Delay(8, &tilticks);                        /* wait about 8 ticks so they can see it */
  386.                 HiliteControl(SnatchHandle(inputDialog, cancel), false);
  387.                 returnVal = true;
  388.                 break;
  389.             case kTabKey:
  390.                 /* I'm filtering the tab key here so the user cannot tab to */
  391.                 /* my inactive edit line */
  392.                 if (GetControlValue((ControlHandle)SnatchHandle(inputDialog, kEditCheckBox)) == false){
  393.                 
  394.                     returnVal = true;                       /* don't allow edit line swaps */}
  395.                 break;
  396.         }
  397.     }
  398.     
  399.     /********************************************************************************/
  400.     /* Here's another kind of key filtering you need every so often, text or numeric */
  401.     /* filtering.  In this case, we're only going to allow non-numeric characters in */
  402.     /* the second edit line we have installed in this dialog */
  403.     /* Any number will be eaten, and a beep generated */
  404.     /**************************************************/
  405.     if (wasAKey) {
  406.         theKey = myDialogEvent->message & charCodeMask;
  407.         
  408.         if ((theKey > 0x30 && theKey < 0x39) && ((DialogPeek)inputDialog)->editField + 1 == kBottomEditLine) {
  409.             /* Dang, it's a number and in the wrong edit line, reject it */
  410.             SysBeep(1);                                     /* complain a little */
  411.             returnVal = true;                               /* tell the dialog manager */
  412.                                                             /* that we handled this already and */
  413.             /* it doesn't have to, so the keystroke will _not_ get */
  414.             /* added to the edit line */
  415.             
  416.         }
  417.     }
  418.     
  419.     /********************************************************************************/
  420.     /* Here's yet another kind of key filtering you need every so often.  */
  421.     /* I'm going to restrict the amount of text in the top edit line to just 25 characters */
  422.     /**************************************************/
  423.     /* •• NOTE: Remember Cut/Copy/Paste! */
  424.     /* Before you allow these, you need to see what the result of a Paste (in this case) */
  425.     /* will be, since a Paste can also drive you over the 25 char limit. */
  426.     /* I've modified the function IsEditKey to look for these */
  427.     /* I've also added code that checks to see if there is a selection range, */
  428.     /* since typeing one charater to replace 5 is OK */
  429.     
  430.     /* First, see if it was a key and the top edit line is active */
  431.     if ((wasAKey) && ((DialogPeek)inputDialog)->editField + 1 == kTopEditLine) {
  432.         selection = HasSelectionRange((DialogPeek)inputDialog);
  433.         scrapLen = GetScrap(nil, 'TEXT', &offset);
  434.         GetDialogItem(inputDialog, kTopEditLine, &tempItem, &tempHandle, &tempRect);
  435.         GetDialogItemText(tempHandle, myStr);
  436.         /* calculate the result of adding the scrap to the current record.  We use */
  437.         /* this in a few places here */
  438.         resultLen = myStr[0] + (scrapLen - selection);
  439.         theKey = myDialogEvent->message & charCodeMask;
  440.         tempKey = theKey;
  441.         if (tempKey >= 0x61 && tempKey <= 0x7a)
  442.             tempKey -= 0x20;
  443.         if (myStr[0] > 25) {                                /* over 25, see what it is */
  444.             if (IsEditKey(theKey, myDialogEvent->modifiers)) {
  445.                 /* it was an editing key, but it MAY be a command-V. */
  446.                 /* If it's a command-V then we won't allow it UNLESS */
  447.                 /* there is a slection range AND the new data won't overrun things */
  448.                 if ((tempKey == 'V') && (myDialogEvent->modifiers & cmdKey)) {
  449.                     
  450.                     /* this was a paste.  check selection range and scrap len  */
  451.                     if (resultLen < 26) {
  452.                         returnVal = false;                  /* net result is  25 or less */
  453.                     } else {
  454.                         SysBeep(1);
  455.                         returnVal = true;
  456.                     }
  457.                 } else {
  458.                     returnVal = false;                      /* don't filter out editing keys */
  459.                 }
  460.             } else {
  461.                 /* One more check (this can get complicated, huh?) */
  462.                 /* We now look to see if there is a selection range.  If there */
  463.                 /* is a range of 1 or more characters, then the one character they are entering */
  464.                 /* now will replace that, and we'll end up with _less_ than 25 (or equal) */
  465.                 /* to do this, we have to get the TERecord out of the dialog.  */
  466.                 /* I'm going to do this in a seperate function */
  467.                 if (selection == nil) {
  468.                     SysBeep(1);                             /* complain a little */
  469.                     returnVal = true;                       /* tell the dialog manager that we handled this already and */
  470.                     /* it doesn't have to, so the keystroke will _not_ get */
  471.                     /* added to the edit line */
  472.                 }
  473.             }
  474.         } else {
  475.             /* even if we're less than 25 currently, a Command-V (paste) could put us over */
  476.             /* so check it out */
  477.             
  478.             if ((tempKey == 'V') && (myDialogEvent->modifiers & cmdKey)) {
  479.                 
  480.                 /* Gettting the scrap with a nil handle, which does not give us data, just */
  481.                 /* returns the size */
  482.                 if (resultLen > 25) {
  483.                     SysBeep(1);                             /* complain a little */
  484.                     returnVal = true;                       /* tell the dialog manager that we handled this already and */
  485.                     
  486.                 }
  487.             }
  488.         }
  489.     }
  490.     /* We are doing three checks here in the dialog filter for  mouseDown */
  491.     /* events. */
  492.     /* The first checks to see if we're in the icon of that Charismatic Dude */
  493.     /* Fred, and tracks it like a control if we are. */
  494.     /* If we're not, then we may be in our scroll bar, and we have to */
  495.     /* do various things if that is true. */
  496.     /* Or, we may be in the disabled edit line, and we have to disallow clicks on it */
  497.     /* when it's disabled */
  498.     
  499.     if (myDialogEvent->what == mouseDown) {
  500.         mousePoint = (myDialogEvent->where);
  501.         GlobalToLocal(&mousePoint);
  502.         /* First see if we're in Fred */
  503.         GetDialogItem(inputDialog, kFredIconItem, &tempItem, &tempHandle, &tempRect);
  504.         if (PtInRect(mousePoint, &tempRect)) {
  505.             /* invert my icon, and track it whilst the user holds the mouse down */
  506.             InvertRect(&tempRect);
  507.             hiLit = true;
  508.             while (StillDown()) {
  509.                 GetMouse(&tempPoint);                       /* returns point in local coords */
  510.                 if (PtInRect(tempPoint, &tempRect)) {
  511.                     /* in the rect.  See if it's hilighted or not */
  512.                     if (hiLit == false) {
  513.                         hiLit = true;
  514.                         InvertRect(&tempRect);
  515.                     }
  516.                 } else {
  517.                     /* not in the rectangle.  If it's hilit, get rid of that */
  518.                     if (hiLit == true) {
  519.                         hiLit = false;
  520.                         InvertRect(&tempRect);
  521.                     }
  522.                 }
  523.             }
  524.             if (hiLit == true) {
  525.                 /* if it's still hilited when the mouse comes up, then that means the */
  526.                 /* user stayed in and wants to take this icon action */
  527.                 InvertRect(&tempRect);                      /* clear the hiliting if it's still lit */
  528.                 *theDialogItem = kFredIconItem;
  529.                 returnVal = true;                           /* telling the Dialog Manager we handled it, pass item back */
  530.             }
  531.         } else {
  532.             /* Now see if we're in the scroll bar  */
  533.             
  534.             GetDialogItem(inputDialog, kScrollControlItem, &tempItem, &tempHandle, &tempRect);
  535.             if (PtInRect(mousePoint, &tempRect)) {
  536.                 /* We're in the scroll bar. */
  537.                 /* Now, what does that mean???? */
  538.                 /* Well, the Dialog Manager will automatically call FindControl and TrackControl */
  539.                 /* and set the control value (in the case of scroll thumbs) */
  540.                 /* on controls added to your dialog, and in many cases that's all you're going */
  541.                 /* to need. */
  542.                 /* But, ModalDialog does NOT pass back a part code, so if the userPerson */
  543.                 /* clicked on the thumb or arrows of the scroll bar, you won't know, you'll */
  544.                 /* just know that the  scroll bar was clicked in.*/
  545.                 /* That's not enough, so we'll to an initial check to see where the control */
  546.                 /* was hit */
  547.                 thePart = FindControl(mousePoint, inputDialog, &returnedControl);
  548.                 /* if the hit was in an arrow or page area, we'll handle it ourselfs */
  549.                 if (thePart != 129) {
  550.                     TrackControl(returnedControl, mousePoint, gControlActionUPP);
  551.                     returnVal = true;
  552.                 }
  553.                 /* if it was in the thumb, we'll just fall through and let the Dialog Manager */
  554.                 /* handle it for us */
  555.             } else {
  556.                 /* first see if we even care about this click.  If the check box is true, then */
  557.                 /* both edit lines are active, let the dialog manager handle it */
  558.                 if (GetControlValue(SnatchHandle(inputDialog, kEditCheckBox))) {
  559.                     returnVal = false;                      /* DM will handle */
  560.                 } else {
  561.                     /* OK, so the edit line checkbox is NOT set, which means that we don't want */
  562.                     /* hits in the inactive edit line to do anything.  So, see if the hit was */
  563.                     /* in the edit line, and report 'true' if it was, telling the Dialog Manager that */
  564.                     /* you handled the event and it should do nothing */
  565.                     GetDialogItem(inputDialog, kBottomEditLine, &tempItem, &tempHandle, &tempRect);
  566.                     if (PtInRect(mousePoint, &tempRect)) {
  567.                         returnVal = true;
  568.                     } else {
  569.                         returnVal = false;
  570.                     }
  571.                 }
  572.             }
  573.         }
  574.     }
  575.     /* one final thing if we're under System 7, */
  576.     /* calling the standard filter. */
  577.     /* You MUST call the standard filter if you want any of the  */
  578.     /* new things to happen! */
  579.     /* The OK button border, cursor tracking, and the rest ONLY */
  580.     /* happen if you call the filter! */
  581.     /* I am also only doing this if the returnValue is still false.  If I have */
  582.     /* set it to true somewhere in here, I don't want to call the stdFilter */
  583.     if (gNewDialog && !returnVal) {
  584.         
  585.         myErr = GetStdFilterProc(&theModalProc);
  586.         if (myErr == noErr)
  587.         returnVal = CallModalFilterProc(theModalProc, inputDialog, myDialogEvent, theDialogItem);
  588.     }
  589.     return(returnVal);
  590. } /* end filterIt */
  591.  
  592. /* SpinIt animates my fancy icon */
  593. void SpinIt(DialogPtr theDialog)
  594. {
  595.     static short pos;
  596.     static long count;
  597.     Handle myIcon;
  598.     Rect tempRect;
  599.     short tempItem;
  600.     Handle tempHandle;
  601.     /* I'm adjusting the speed of the spin based on the value of the scroll bar */
  602.     if (TickCount() > count + (10 - GetControlValue(SnatchHandle(theDialog, kScrollControlItem)))) {
  603.         count = TickCount();                                /* reset count to next value */
  604.         myIcon = GetIcon(pos + kBaseSpinIcon);
  605.         /* you could have a rect in this function, but that'd require you to change it all 
  606.         * the time when you move the item around in your dialog.  So, we'll reference it 
  607.         * from the dialog record instead */
  608.         /* make sure we really got the handle */
  609.         if (myIcon != nil) {
  610.             GetDialogItem(theDialog, kSpinItem, &tempItem, &tempHandle, &tempRect);
  611.             PlotIcon(&tempRect, myIcon);
  612.             ReleaseResource(myIcon);
  613.         }
  614.         pos++;
  615.         if (pos > 3)
  616.             pos = 0;
  617.     }
  618. } /* end SpinIt */
  619.  
  620. /* BorderDefault draws a heavy border around the default button (in this case the OK button ) */
  621. /* Again, not necessary if the new DM calls are in */
  622. pascal     void BorderDefault(WindowPtr dwind, short dinum)
  623. {
  624. #pragma unused (dinum)
  625.     short itemtype;
  626.     Handle itemhandle;
  627.     Rect borderRect;
  628.     GetDialogItem(dwind, ok, &itemtype, &itemhandle, &borderRect);
  629.     /* ok is defined as 1 in the interfaces.  If you'd like another item outlined, */
  630.     /* change this number, of course. */
  631.     InsetRect(&borderRect, -4, -4);
  632.     PenSize(3, 3);
  633.     FrameRoundRect(&borderRect, 16, 16);
  634.     PenSize(1, 1);
  635. } /* end BorderDefault */
  636.  
  637. /* This userItem dims the bottom edit line if the check box is not checked */
  638. pascal     void DimEditLine(WindowPtr dwind, short dinum)
  639. {
  640.     ControlHandle tempCont;
  641.     tempCont = SnatchHandle(dwind, kEditCheckBox);
  642.     /* only do it if the checkbox is false */
  643.     if (GetControlValue(tempCont) == false) {
  644.         PenState thePen;
  645.         short itemType;
  646.         Handle itemHandle;
  647.         Rect dimRect;
  648.         /* Save and restore the pen state so we don't mess things up for other */
  649.         /* drawing routines */
  650.         GetPenState(&thePen);
  651.         GetDialogItem(dwind, dinum, &itemType, &itemHandle, &dimRect);
  652.         PenMode(notPatBic);
  653.         PenPat(&qd.gray);
  654.         PaintRect(&dimRect);
  655.         SetPenState(&thePen);
  656.         
  657.     }
  658. } /* end DimEditLine */
  659.  
  660. /* a little utility to see if the current key is an edit-type key */
  661. Boolean IsEditKey(char theKey, short modifiers)
  662. {
  663.     register qq;
  664.     Boolean returnVal = false;
  665.     char editChars[] =  {
  666.         kLeftArrow, kUpArrow, kRightArrow, kDownArrow, kBackSpace, kEscKey
  667.     };
  668.     char commandEdits[] =  {
  669.         'C', 'V', 'P'
  670.     };
  671.     for (qq = 0; qq < sizeof(editChars) / sizeof(char); qq++) {
  672.         if (theKey == editChars[qq])
  673.             returnVal = true;
  674.     }
  675.     if (returnVal != true && (modifiers & cmdKey)) {
  676.         /* check for XCP */
  677.         /* Do you want me to use toupper?  What! And link in all of StdLib! aggggg */
  678.         if (theKey >= 0x61 && theKey <= 0x7a)
  679.             theKey -= 0x20;
  680.         for (qq = 0; qq < sizeof(commandEdits) / sizeof(char); qq++) {
  681.             if (theKey == commandEdits[qq])
  682.                 returnVal = true;
  683.         }
  684.     }
  685.     return(returnVal);
  686. } /* end IsEditKey */
  687.  
  688. /* changes the cursor to an IBeam if it's over an active edit line, or to the */
  689. /* arrow if it's not */
  690. /* Again, not necessary if the new DM calls are in */
  691. void IBeamIt(WindowPtr dwind)
  692. {
  693.     Point mouseAt;
  694.     short itemtype;
  695.     Handle itemhandle;
  696.     Rect borderRect;
  697.     short itemNum;
  698.     /* first get the current edit line out of the dialog record */
  699.     itemNum = ((DialogPeek)dwind)->editField + 1;           /* always stored 1 less */
  700.     GetDialogItem(dwind, itemNum, &itemtype, &itemhandle, &borderRect);
  701.     GetMouse(&mouseAt);
  702.     if (PtInRect(mouseAt, &borderRect)) {
  703.         SetCursor(*(GetCursor(1)));
  704.     } else {
  705.         /* This means I'm callng InitCursor every time through my filter */
  706.         /* this is a little excessive (ha!) but doesn't hurt anything. */
  707.         /* You could set a global or something if this really offends you */
  708.         InitCursor();
  709.         
  710.     }
  711. } /* end IBeamIt */
  712.  
  713. /* Gets the ControlHandle for the item you want in the dialog box thebox.  */
  714. /* Handy for setting checkboxes and radio buttons */
  715. /* This is the _most_ copied routine from this file */
  716. ControlHandle SnatchHandle(DialogPtr thebox, short theGetItem)
  717. {
  718.     short itemtype;
  719.     Rect itemrect;
  720.     Handle thandle;
  721.     
  722.     GetDialogItem(thebox, theGetItem, &itemtype, &thandle, &itemrect);
  723.     return((ControlHandle)thandle);
  724. } /* end SnatchHandle */
  725.  
  726. /* This little routine adjusts the scroll bar during TrackControl */
  727. pascal     void DoScrollArrows(ControlHandle theControl, short thePart)
  728. {
  729.     short currentVal = GetControlValue(theControl);
  730.     short offSet = 0;
  731.     switch (thePart) {
  732.         case 20:
  733.             offSet = -1;
  734.             break;
  735.         case 21:
  736.             offSet = 1;
  737.             break;
  738.         case 22:
  739.             offSet = -3;
  740.             break;
  741.         case 23:
  742.             offSet = 3;
  743.             break;
  744.             
  745.     }
  746.     /* set the control value to the new one, as long as it doesn't pass limits */
  747.     currentVal += offSet;
  748.     if (currentVal < 1)
  749.         currentVal = 1;
  750.     if (currentVal > 10)
  751.         currentVal = 10;
  752.     SetControlValue(theControl, currentVal);
  753.     
  754. } /* end DoScrollArrows */
  755.  
  756. short HasSelectionRange(DialogPeek inputDialog)
  757. {
  758.     TEHandle theTERecord = inputDialog->textH;
  759.     short returnVal = (*theTERecord)->selEnd -(*theTERecord)->selStart;
  760.     
  761.     return(returnVal);
  762. } /* end HasSelectionRange */
  763.  
  764. /* This NOP routine is here in case the ShortenDITL call is not */
  765. /* available but the new dialog manager calls are.  In that case I don't */
  766. /* want to have the bordering box, but I have to have the user item */
  767. /* pointing at something */
  768. pascal     void NOPRoutine(WindowPtr dwind, short dinum)
  769. {
  770. #pragma unused (dwind,dinum)
  771. } /* end NOPRoutine */
  772.  
  773. // check to see if a given trap is implemented. We follow IM VI-3-8.
  774.  
  775. Boolean TrapAvailable(short theTrap)
  776. {
  777.     TrapType theTrapType;
  778.     short numToolboxTraps;
  779.     
  780.     if ((theTrap & 0x0800) > 0)
  781.         theTrapType = ToolTrap;
  782.     else
  783.         theTrapType = OSTrap;
  784.  
  785.     if (theTrapType == ToolTrap)
  786.     {
  787.         theTrap = theTrap & 0x07ff;
  788.         if (NGetTrapAddress(_InitGraf, ToolTrap) == NGetTrapAddress(0xaa6e, ToolTrap))
  789.             numToolboxTraps = 0x0200;
  790.         else
  791.             numToolboxTraps = 0x0400;
  792.         if (theTrap >= numToolboxTraps)
  793.             theTrap = _Unimplemented;
  794.     };
  795.  
  796.     return (NGetTrapAddress(theTrap, theTrapType) != NGetTrapAddress(_Unimplemented, ToolTrap));
  797. }
  798.